Dynamic Firmware Updating

ABSTRACT

A dynamic firmware update process includes finding an updated version of a dynamic data-object in firmware memory. A callback handle for an in-use version of the dynamic data object in use by a consumer is identified. The consumer of updated version of dynamic data object is notified using the callback handle.

BACKGROUND

Modern computers and computer-based systems typically include platform firmware, i.e., code (representing instructions and non-instruction-type data) stored in non-volatile “firmware” memory and used for initializing and for low-level functionality of a computer-based system. Typically, firmware code is loaded into relatively fast volatile memory for use.

It is sometimes desirable to update firmware, e.g., to fix firmware bugs, to add features, or to tweak system parameters. In older computer systems, updating firmware can involve swapping out one firmware read-only-memory (ROM) encoded with the firmware to be replaced for another encoded with the updated firmware. More recently, firmware is stored in rewritable non-volatile memory so that firmware updates can be updated in place. Such updates can take effect once the system is reinitialized, i.e., rebooted.

BRIEF DESCRIPTION OF THE DRAWINGS

The following figures represent examples and not the invention itself.

FIG. 1 is a schematic diagram of a system in accordance with an example.

FIG. 2 is a flow chart of a data-object request handling process implementable on the system of FIG. 1 and in accordance with an example.

FIG. 3 is a flow chart of a firmware-update process implementable on the system of FIG. 1 and in accordance with an example.

FIG. 4 is a schematic diagram of another system in accordance with an example.

FIG. 5 is a flow chart of a firmware-update process implementable on the system of FIG. 4 and in accordance with an example.

DETAILED DESCRIPTION

In a mission-critical context, e.g., network-supported medical alert and other emergency services, financial transactions, and online retailing, in which computers are expected to be “highly available”, rebooting a system to complete installation of firmware can be costly. Examples herein allow some firmware updates to be implemented without rebooting. This not only saves costs associated with rebooting, but also encourages wider use of firmware updates, e.g., enhancing performance by dynamically tweaking firmware parameters. Herein, firmware updates are “dynamic” if they can be implemented (i.e., put to use, as opposed to merely being written) without rebooting.

An example system 100, shown in FIG. 1, includes storage media 102 encoded with code 104. Code 104 includes firmware 112 and a data manager 114 (which, depending on the variation, may or may not be in firmware). Data of firmware 112 is arranged in dynamic-data volumes, e.g., volumes 116 and 118. Each data volume includes data-object meta-data to specify: a data-object identifier (ID) 120, a data-object version ID 122, and a data object 126. Data manager 114 manages requests 128 from consumers (e.g., software entities) for firmware data objects. Data manager keeps track of which consumers are using which data objects in a data structure 130 that stores data object IDs 134 in association with consumer callback handles 134.

Data manager 114 is to implement a data-object request handling process 200, flow charted in FIG. 2. At 201, a request for a data object is received from a consumer. At 202, a most-recent version of the requested data object is identified. At 203, a callback handle for the consumer is stored in association with an identity of the requested data object. At 204, the most-recent version of the requested data object is provided to the consumer so that it becomes an “in-use” version of the data object. Process 200 can be implemented by other entities, and data manager 114 can implement other processes, as demonstrated further below.

Data manager 114 can implement a data-object update process 300, flow charted in FIG. 3. At 301, an updated version of a data-object version is found. At 302, a callback handle of a consumer of the data object is identified. At 303, using the callback handle, the consumer of the data object is notified of the update.

Once it is notified of an update, a consumer may request the updated object immediately or at a later time. For example, if requesting and using the updated data object would cause a conflict or other problem in an ongoing procedure, the consumer can wait for a more opportune time to update its copy of the data object. In any event, the dynamic data firmware update can be managed in a way that avoids any coherency problem and without requiring a reboot (which might interfere with service level objectives for a highly available computer system).

As shown in the next example, the data volumes can store data-object metadata other than that shown for system 100. For instance, a data volume can include a security key that can be used to ensure that an update is from an authorized source and is not the result of error or malice.

A computer system 400 includes a processor 402, communications devices 404, and non-transitory storage media 406. Media 406 is encoded with code 408. Code 408 includes firmware 410, consumers 412, a firmware update utility 414, and an update flag 416. In another example, flag 416 is implemented in hardware. Firmware 410 includes a data manager 420, an update handler 422, and data volumes 430, including data volumes 432, 434, and 436.

Each data volume 430 is a combination of a data-volume data structure and its contents. The contents include a data-object ID, a data-object attribute, a data-object version ID, a security key, other metadata, and a data-object. The data-object ID can be a globally-unique identifier (GUID). The data-object attribute specifies whether a given data object is a dynamic data object or a static data object. A dynamic data object for which a change can be implemented without rebooting, while rebooting is required to implement a changed static data object. “Other metadata” can include locations or object size information that can be used to determine where the boundaries of a data volume or a data object value are located. In addition, “other metadata” can include other information characterizing a data object useful to data manager 420 or a consumer 412.

Data volume 432 includes a data-object ID 440, an attribute 442, a version ID 444, a valid flag 445, a security key 446, other metadata 447, and a data-object 448. Attribute 442 is set to “static” so changes (which would be represented by another data volume) to the data-object having data-object ID 440 would only take place after a reboot of system 400. Version ID 444 is the most-recent version, in this case the latest version of the data-object represented among data volumes 430. Data object 448 is the data object that is provided to a consumer 412 in response to a request.

Data volume 434 includes a data-object ID 450, an attribute 452, a version ID 454, a valid flag 455, a security key 456, other metadata 457, and a data-object 458. In this case, attribute 452 is set to “dynamic”, indicating that a change of the data object (value) can be implemented without a reboot. The version ID, which can be a numerical value such as “4.2”, happens to correspond to the in-use version for the data object with ID 450 in that it is currently in use by consumer 412.

However, while in-use data object 458 was the most-recent version at the time it was requested by consumer 412, it is not the most recent version at the time represented in FIG. 4. This is because a newer version has been written to firmware 410 since consumer 412 requested data object 458. This newer updated version is represented in data volume 436.

Data volume 436 includes a data object ID 460, an attribute 462, a version ID 464, a valid flag 465, a security key 466, other metadata 467, and a data-object 468. Data object 468 is an updated version of data object 458. Accordingly, data-object ID 460 equals data-object ID 450, and version ID 464 (e.g., version 4.3) corresponds to a later version than version ID 454 (e.g., version 4.2). Attributes of different versions of an object are generally the same so attributes 452 and 462 are the same, both set at “dynamic”. In some cases, however, an update changes the attribute for a data object.

Data manager 420 keeps track of which consumers are using which data objects. To this end, data manager 420 includes a data structure, e.g., callback table 470, that associates consumer callback handles 472 with data-object identities 474 for each data object currently in use by a consumer and with the data-object version ID for the data object in use. For example, in the time represented in FIG. 4, an object identity for data object 458 would be associated with a consumer callback handle in callback table 470.

System 400 provides for implementation of firmware-update process 500, flow charted in FIG. 5. Process 500 includes a request section 510 and an update section 520. Request section 510 includes action 511, in which a data manager receives from a consumer a request for a data object. The request can specify a GUID or other identifier for the object.

At 512, the data manager searches the data volumes for an appropriate version of the requested data object to fulfill the request. At 513, the data manager finds the appropriate version of the data object. In the illustrated process 500, the appropriate version is the most-recent valid version. Invalid versions, as indicated by their respective valid flags, are not searched. Recency can be determined by comparing version numbers of found valid versions of the requested data object.

Immediately after a data-object update, the updated version can be different from any version in use by a consumer. If another consumer requests a data object for which the most-recent version differs from the in-use version, it may be desirable for consistency to fulfill the request with the in-use version instead of the most-recent version. In such an example and scenario, the in-use version is the “appropriate” version with which to fulfill the request. In the illustrated variation of process 500, an updated version of a data object is not marked “valid” until the data manager has been informed of the updated version. Thus, the data manager can retire the in-use version of a requested data object before fulfilling any additional requests for it with the updated (i.e., most-recent) version.

At 514, the data manager checks the“static” versus “dynamic” attribute for the appropriate version of the data object. At 515, if and only if (iff) the attribute is “dynamic”, the data manager associates the callback handle with the data-object identity and the data-object version identity, e.g., in callback table 470. If the attribute is “static”, no entry is made in the callback table. At 516, the data manager fulfills the request by providing the appropriate version of the data object to the consumer that requested the data object.

Update section 520 of process 500 includes, at 521, an update tool writing an updated data object to a new volume at an unused area of firmware. When a data object is updated, the updated version is written to an empty area of firmware and the previous version is not deleted. However, the update utility may provide “clean-up” of older versions once it is certain that they will not be reverted to or otherwise used. In the illustrated variant of process 500, the valid flag for the updated version is initially set to “invalid”.

At 522, the data manager is notified of the update. In one variant, a data manager discovers updates by polling (e.g., periodically) the data volumes. In another variant, the update tool sets an update flag (e.g., flag 416) and triggers an update handler (e.g., update handler 422). The handler can be triggered using a platform-management interrupt or a system management interrupt (SMI). The update handler then notifies the data manager of the update.

At 523, the data manager searches for and finds the data volumes respectively for the update and its immediate predecessor, which the data manager can identify by their version IDs. At 524, if and only if (iff) the attribute for the predecessor version is “dynamic”, the data manager attempts to validate the updated version of the data object, e.g., by checking the security key for the updated version using the data manager's private key 472. Note, that if all versions of a data object are required to have the same attribute value, then, at 524, the attribute for the updated version can be used instead of the attribute for its predecessor. If, at 524, prior version is “static”, no further action is taken with respect to the update until the next boot, at which time validation is performed.

If the updated version is determined to be valid at 525, the data manager sets its valid flag to “valid” at 526. In another variant of process 500, the update handler performs the validity check and, if and only if the update is valid, informs the data manager of the update and sets the valid flag to “valid”. If an updated version of a data object is determined to be invalid, e.g., the updated version either continues to be marked “invalid” or is deleted.

At 526, the data manager checks its callback table for entries matching the updated dynamic data object. If there are any matches, each associated callback handle is used to inform the respective consumer of the update. At 527, if and only if (iff) the dynamic data object is in use, the data manager notifies the consumer or consumers (that are using the earlier version of the data object) of the update. The data manager can hold requests by other consumers for the same data object until consumers of the earlier data object are no longer using it. Process 500 can then return to 511 without an intervening reboot. The consumer may request the dynamic data object either immediately after the notice or at some later time as appropriate given the use of the prior version of the data object.

An alternative example does not use valid flags in the data-object volumes to indicate validity. Instead, a data manager tracks updates of static data objects internally so that the updates are not used to fulfill a consumer request prior to a reboot. Upon reboot, the data used to track updates is lost, so that, after the reboot, the data manager will fulfill requests using the updated static data objects.

Herein, a “system” is a set of interacting non-transitory tangible elements, wherein the elements can be, by way of example and not of limitation, mechanical components, electrical elements, atoms, physical encodings of instructions, and process actions. Herein, “process” refers to a sequence of actions resulting in or involving a physical transformation.

Herein, unless otherwise clear from context, “data” is used in the inclusive sense that encompasses executable instructions as well as non-instruction-type data. Herein, “data object” encompasses single bits, strings, and arrangements of bits and/or strings. Herein, “storage medium” and “storage media” refer to a system including non-transitory tangible material in or on which information is or can be encoded with data (including instructions and non-instruction-type data) and data objects. Herein, unless otherwise clear from context, “firmware” refers to code stored in persistent (i.e., non-volatile memory) solid-state memory and code resulting from booting code from persistent solid-state memory. “Firmware memory” refers to non-volatile memory used for storing firmware code.

Herein, a “version” is a particular form of a thing, e.g., a data object, that differs in some way from other versions of the same thing. Herein, a data object is said to be “dynamic” if it can be updated and used without a reboot. Herein, a data object is said to be “static” if an update of it cannot be used without a reboot. Herein, a “consumer” is an executing process that requests and uses a data object. Herein, a “callback handle” is a data item used to send information to a process that previously sent a request, e.g., for a data object.

Herein, a “computer” refers to a hardware machine for manipulating physically encoded data in accordance with physically encoded instructions. Herein, unless other apparent from context, a functionally defined component of a computer is a combination of hardware and software executing on that hardware to provide the defined functionality.

Herein, “processor” refers to hardware for executing instructions. A processor can be a monolithic device, e.g., integrated circuit, a portion of a device, e.g., core of a multi-core integrated circuit, or a distributed or collocated set of devices. Herein, “communications devices” refers to devices used for communication, including both network devices and devices used for input and output, e.g., human interface devices.

In this specification, related art is discussed for expository purposes. Related art labeled “prior art”, if any, is admitted prior art. Related art not labeled “prior art” is not admitted prior art. In the claims, “said”, if used, introduces elements for which there is explicit verbatim antecedent basis; “the” introduces elements for which the antecedent basis may be implicit. The illustrated and other described embodiments, as well as modifications thereto and variations thereupon are within the scope of the following claims. 

What is claimed is:
 1. A computer-implemented dynamic firmware update process comprising: finding an updated version of a dynamic data object in firmware memory; identify a callback handle for an in-use version of the dynamic data object in use by a consumer; and notifying, using the callback handle, the consumer of the updated version of the dynamic data object.
 2. A process as recited in claim 1 further comprising: prior to the finding, writing the updated version of the firmware dynamic data object to firmware memory without overwriting any prior version of the dynamic data object.
 3. A process as recited in claim 2 wherein the notifying follows the writing without an intervening reboot.
 4. A process as recited in claim 2 wherein the finding is performed by a data manager represented in the firmware, and said writing the updated version is performed by an update utility.
 5. A process as recited in claim 1 further comprising: after the notifying, receiving from the consumer a request for the dynamic data object; in response to the request, writing a callback handle for the consumer in association with the updated version of the dynamic data object; and in response to the request, providing the updated data object to the consumer.
 6. A process as recited in claim 5 further comprising receiving a request from a consumer for a second data object in firmware memory; determining whether an attribute for the second data object indicates that the second data object is static or dynamic; and if and only if the attribute indicates that the second data object is dynamic, searching for other versions of the second data object in firmware memory.
 7. A system comprising non-transitory storage media encoded with code defining a data manager and firmware, the firmware including data volumes including respective data-object versions along with associated data-object identifiers (IDs) and data-object version IDs, the data manager being executable by a processor to: in response to a request from a consumer for a dynamic data object, identify a most-recent version of the dynamic data object using a data-object ID for the data object and data-object version IDs for different versions of the dynamic data object; store a callback handle for the consumer in association with the most-recent version of the dynamic data object; and provide the most-recent version of the dynamic data object to the consumer so that the dynamic data object becomes an in-use dynamic data object.
 8. A system as recited in claim 7 further comprising the processor.
 9. A system as recited in claim 7 wherein the data manager is further executable to: after the providing, find an updated version of the in-use dynamic data object; identify a callback handle in association with the in-use dynamic data object; and notify, using the callback handle, the consumer of the existence of the updated version.
 10. A system as recited in claim 7 wherein some of the data objects are static data objects for which updates can only be put in use after a reboot following the writing of the updated static data object to a data volume of the firmware, said volumes including an attribute for each data object version indicating whether the data object is static or dynamic.
 11. A system as recited in claim 7 wherein the code further defines a firmware update utility to prepare a new data-object volume including an updated version of a data object into firmware so that it becomes a most-recent version of that data object, the volume specifying a data-object ID, a data-object version ID, and a static-vs.-dynamic attribute for the data object, the new data-object volume including a field for entering a callback handle for a consumer.
 12. A system as recited in claim 11 wherein the code further defines an update handler, the firmware update utility being further to set a flag to indicate that an update has been written to firmware and to trigger the update handler, which, in response to the trigger, notifies the data manager of the update.
 13. A computer-implemented process comprising: finding an updated version of a data object; identifying a callback handle for an in-use version of the data object; and using the callback handle, notifying a consumer of the data object of the existence of the updated version of the data object.
 14. A computer-implemented process comprising: receiving a request for a data object from a consumer; identifying in firmware memory a most-recent of plural versions of the data object; store a callback handle for the consumer in association with an identify of the data object; and provide the most-recent version to the consumer.
 15. A process as recited in claim 14 further comprising: writing the most-recent version of the data object to firmware memory; and in response to the writing, notifying the consumer of the update. 